//自行车x:00到x:20最大1单 y:20到y+1:20最大3单    bike20minsOrderAmount = 1     bike1hourOrderAmount = 3
//电瓶车x:00到x:20最大2单 y:20到y+1:20最大4单	 electricMobile20minsOrderAmount = 2     electricMobileOrderAmount = 4
//汽车x:00到x:20最大3单 y:20到y+1:20最大5单      car20minsOrderAmount = 3     car1hourOrderAmount = 5

//GetBackTime 增加返回时间x
//配货时间x
//Weight 增加配送员的携带重量 装载量最大化ok
//not just one hour 不是正好在1小时开始发货 比如9点营业在9:15分收到第一个订单ok
//提醒发货ok
//跨小时送货ok
//提醒增加外送端ok
//TimeBucket 增加用户设置的时间段非下一小时





//假设一个送货员交通工具为电瓶车，最大携带重量50

//假设营业时间是9点到24点  如果9点到9点20分大于2个订单 提醒商家现在有N个订单  请酌情增加外送员  客户端显示9点到10点的订单已被排满 任意1小时前20分钟之后不接受本小时送达的订单
//上一整点前20分钟到下一整点前20分钟之间如9点20分到10点20分订单数量大于4 提醒商家现在有N个订单  请酌情增加外送员 客户端显示10点到11点的订单已被排满 
//若9点20分到10点没有订单  那么10点到10点20分就跟9点到9点20分情况一样
//半点提醒必须发货，超重提醒发货并提醒增加送货员
//若arrayDistanceBetweenN中的distance有大于5公里的，建议增加送货员并提示订单间距离过大
//若整点前20分钟下单数大于4，则下单时间晚的放入下一时间段

//看接受下单时间内的订单有没有超过可接受的订单数，不超过则放入deliveryOrder中相应时间段计算顺序，超过则把下单时间晚的放入deliveryOrder中下一个送货时间段，其余放入deliveryOrder中现在时间段并计算送货顺序
//把可送货的订单放入arrayN，算出与店铺距离最近的修改deliveryOrder中的此订单的orderId为1
//如果可送货订单<2，则直接送货，=2，则deliveryOrder中当前时间段的另一个订单orderId改为2，并送货
//如果可送货订单>2,则将订单放入arrayDistanceBetweenN中，将与第一个订单有关的放入arrayDistance中并删除arrayDistanceBetweenN中的相同内容，从arrayDistance中计算出与前一个订单距离最近的并修改deliveryOrder中的相应订单的orderId，以此类推计算出送货顺序
//同一时间段内如超过最大携带重量则提醒超重并提示增加送货员

//算法分两部分  第一部分是根据送货员情况将订单放入deliveryOrder对应的时间段中    第二部分算法是将deliveryOrder中各时间段的订单的送货顺序计算出来
//分两种情况  第一种为x-1:20到x:00无订单  x:00到x:20出现订单  此处假定为9:00到9:20即8:20到9:00没有订单(没有开门自然没有订单)
//第二种情况为x:20到x+1:20  此处假定9:20到10:20分陆续出现订单   同时注意10:00到10:20最多只能出现2个订单
//每次计算完订单都要计算重量是否超过最大携带重量，超重则提醒增加送货员

//一个送货员 deliveryMan = 1，  交通工具电瓶车  则in20minsOrderAmount = 2* deliveryMan == 2    in1hourOrderAmount = 4*deliverMan == 4
//electricMobile20minsOrderAmount =2    electricMobile1hourOrderAmount = 4   对应上方的2和4
//以下为算法A  时间段9:00到9:20 
if(9:00到10:00时间段的订单数==4 || (9:00之前确定的9:00到10:00的订单数<=2 && 9:00到9:20的10:00订单数==2) || orderClock > 9:20){
	订单放入下一小时并再用算法A计算订单是否能放入下一小时，若不能放入则用算法A计算再下一小时的情况
	}
//现进来如下订单
N1 = {id:1, distance=3, orderClock:9:05, weight:15, arriveBeginClock:9:00, arriveEndClock:10:00};
N2 = {id:2, distance=4, orderClock:9:10, weight:26, arriveBeginClock:9:00, arriveEndClock:10:00};
N3 = {id:3, distance=5, orderClock:9:15, weight:40, arriveBeginClock:9:00, arriveEndClock:10:00};

//根据算法A的条件判断deliveryOrder的内的订单
deliveryOrder = [timePeriod:{10:[{orderId:0, id:1},{orderId:0, id:2}], 11:[{orderId:0,id:3}], 12...}];
//计算订单顺序
//得出distance与店铺最近的 修改deliveryOrder中相应内容的orderId为1,因为只有2个订单 所以另一个订单orderId为2
deliveryOrder = [timePeriod:{10:[{orderId:1, id:1},{orderId:2, id:2}], 11:[{orderId:0,id:3}], 12...}];
//计算重量是否超过最大携带重量，超重则提醒增加送货员并提醒立即发货


//算法A更改
//将arriveBeginClock arriveEndClock与orderClock做比较   可能出现如下集中情况
//举例  假设目前时间为10点到11点 
//情况1：假设现在是10点10分 则orderClock=10：10  而arriveBeginClock=9：00   arriveEndClock=10：00  则需返回给客户重新选择时间 此单不成功  不能下单  因为时间已过
//情况2：假设orderClock=10：10   则通过orderClock可以判断出最快的送货时间是10：00到11：00  因为orderClock在10点到10点20之间  arriveBeginClock=10：00  arriveEndClock=11：00  
//判断10:00之前确定的10:00到11:00的订单数<=2 && 10:00到10:20的确定的10：00到11:00订单数==2  则订单已满无法加入该时间段  需返回给客户重新选择时间
//情况3：假设orderClock=10:30  则通过orderClock可以判断出最快的送货时间是11：00到12：00  因为orderClock在10点20到11点20分之间 假设arriveBeginClock=11：00  arriveEndClock=13：00  则若arriveEndClock=12：00
//判断11:00到12:00时间段的订单数==4  则订单已满无法加入该时间段   需返回给客户重新选择时间  但此处arriveEndClock=13：00  对应的arriveBeginClock跨了2小时 处理方法见情况4
//简单说明就是还要算一遍arriveBeginClock arriveEndClock为12点到13点的情况
//情况4：假设orderClock=10：30  则通过orderClock可以判断出最快的送货时间是11：00到12：00 而订单的arriveBeginClock=13：00  arriveEndClock=15：00 
//则先判断13:00到14:00时间段的订单数==4 得知该时间段订单已满 再判断14：00到15：00时间段的订单数  若又已满 则需返回给客户重新选择时间 无法加入该时间段  即13点到15点
//补充说明  此处增加一个元素或者key 名称为immediately  如果值为true 并且该订单没有发货 则在增加外送员的时候这个订单将被重新计算 前台会显示为选择了越快越好 可任意时间提早到货
//因为选择了越快越好，可任意时间提早到货   所以再次计算的时候订单的到货时间越早越好  即本小时不行到下一小时  下一小时不行到再下一小时...



//以下为算法A  时间段9:20到10:20
if(9:00到10:00时间段的订单数==4 || (9:00之前确定的9:00到10:00的订单数<=2 && 9:00到9:20的10:00订单数==2) || orderClock > 9:20){
	订单放入下一小时并再用算法A计算订单是否能放入下一小时，若不能放入则用算法A计算再下一小时的情况
	}

//现进来如下订单
N1 = {id:1, distance=1, orderClock:9:30, weight:15, arriveBeginClock:10:00, arriveEndClock:11:00};
N2 = {id:2, distance=2, orderClock:9:40, weight:26, arriveBeginClock:10:00, arriveEndClock:11:00};
N3 = {id:3, distance=3, orderClock:9:50, weight:40, arriveBeginClock:10:00, arriveEndClock:11:00};	
N4 = {id:4, distance=4, orderClock:10:00, weight:30, arriveBeginClock:10:00, arriveEndClock:11:00};
N5 = {id:5, distance=5, orderClock:10:10, weight:10, arriveBeginClock:10:00, arriveEndClock:11:00};
//根据算法A的条件判断deliveryOrder的内的订单
deliveryOrder = [timePeriod:{...,11:{orderId:0, id:1},{orderId:0, id:2},{orderId:0, id:3},{orderId:0,id:4}], 11:[{orderId:0, id:5}], ...}];
//计算订单顺序
//得出distance与店铺最近的 根据订单数量判断计算方法
//以下为算法B
if(订单数<2){
		直接派送
	}else if(订单数=2){
		按45行-49行方式计算
	}else if(订单数>2){
		//将该时间段订单放入arrayN  计算出每个订单间距离放入arrayDistanceBetweenN;
		arrayN = [{id:1, distance=1}, {id:2, distance=2},{id:3, distance=3},{id:4, distance=4}];
		arrayDistanceBetweenN = [{beginId:1, endId:2, distance=1}, {beginId:1, endId:3, distance=2},{beginId:1, endId:4, distance=3},
								 {beginId:2, endId:3, distance=4},{beginId:2, endId:4, distance=5}
								 {beginId:3, endId:4, distance=2}];  
		//获得arrayN中distance最近的一个，修改deliveryOrder中相应内容的orderId 
		//将arrayDistanceBetweenN中与此订单有关的内容放入arrayDistance并删除arrayDistanceBetweenN中相应订单
		deliveryOrder = [timePeriod:{...,11:{orderId:1, id:1},{orderId:0, id:2},{orderId:0, id:3},{orderId:0,id:4}], 11:[{orderId:0, id:5}], ...}];
		if(arrayDistanceBetweenN[i].beginId=id || arrayDistanceBetweenN[i].endId=id) {
		//将arrayDistanceBetweenN中与id成对的元素加到arrayDistance中
		}
		//得到
		arrayDistance = [{beginId:1, endId:2, distance=1}, {beginId:1, endId:3, distance=2},{beginId:1, endId:4, distance=3}]; //这里的distance是假设值
		//再取arrayDistance中distance的最小值（有相同值则取成对的beginId或endId小的那个）赋值给deleteId=id id=成对的那个beginId或endId
		//由deleteId 删除arrayDistanceBetweenN中的任何beginId或endId为deleteId的元素
		//for循环
		if(arrayDistanceBetweenN[i].beginId=deleteId || arrayDistanceBetweenN[i].endId=deleteId) {
		//删除这个元素
		}
		//得到	
		arrayDistanceBetweenN = [{beginId:2, endId:3, distance=4},{beginId:2, endId:4, distance=5}
								 {beginId:3, endId:4, distance=2}];  
		//重复算法B
		//计算arrayDistance中与orderId1距离最近的一个，修改orderId为2
		deliveryOrder = [timePeriod:{...,10:{orderId:1, id:1},{orderId:2, id:2},{orderId:0, id:3},{orderId:0,id:4}], 11:[{orderId:0, id:5}], ...}];
		//计算arrayDistance中与orderId2距离最近的一个，修改orderId为3
		deliveryOrder = [timePeriod:{...,10:{orderId:1, id:1},{orderId:2, id:2},{orderId:3, id:3},{orderId:0,id:4}], 11:[{orderId:0, id:5}], ...}];
		//剩下的一个orderId为4
		deliveryOrder = [timePeriod:{...,10:{orderId:1, id:1},{orderId:2, id:2},{orderId:3, id:3},{orderId:4,id:4}], 11:[{orderId:0, id:5}], ...}];
	}
//计算重量是否超过最大携带重量，超重则提醒增加送货员并提醒立即发货
//再用算法A计算10点到11点以及11点到12点甚至之后的送货顺序




//两个送货员 deliveryMan = 2，  交通工具电瓶车  则in20minsOrderAmount = 2* deliveryMan == 4    in1hourOrderAmount = 4*deliverMan == 8
//electricMobile20minsOrderAmount =2    electricMobile1hourOrderAmount = 4   对应上方的2和4
//以下为算法A  时间段9:00到9:20
if(9:00到10:00时间段的订单数==8 || (9:00之前确定的9:00到10:00的订单数<=4 && 9:00到9:20的10:00订单数==4) || orderClock > 9:20){
	订单放入下一小时并再用算法A计算订单是否能放入下一小时，若不能放入则用算法A计算再下一小时的情况
	}
//现进来如下订单
N1 = {id:1, distance=1, orderClock:9:05, weight:15, arriveBeginClock:9:00, arriveEndClock:10:00};
N2 = {id:2, distance=2, orderClock:9:10, weight:26, arriveBeginClock:9:00, arriveEndClock:10:00};
N3 = {id:3, distance=3, orderClock:9:15, weight:40, arriveBeginClock:9:00, arriveEndClock:10:00};
N4 = {id:4, distance=4, orderClock:9:16, weight:40, arriveBeginClock:9:00, arriveEndClock:10:00};
N5 = {id:5, distance=3, orderClock:9:18, weight:40, arriveBeginClock:9:00, arriveEndClock:10:00};
//根据算法A的条件判断deliveryOrder的内的订单
deliveryOrder = [timePeriod:{10:[{orderId:0, id:1},{orderId:0, id:2},{orderId:0, id:3},{orderId:0, id:4}], 11:[{orderId:0,id:5}], 12...}];
//以下是算法C 先算10点
		arrayN = [{id:1, distance=1}, {id:2, distance=2},{id:3, distance=3},{id:4, distance=4}];
		arrayDistanceBetweenN = [{beginId:1, endId:2, distance=10}, {beginId:1, endId:3, distance=2},{beginId:1, endId:4, distance=3},
								 {beginId:2, endId:3, distance=4},{beginId:1, endId:4, distance=5}
								 {beginId:3, endId:4, distance=8}];  
//取arrayDistanceBetweenN.ditance的最大值  如果有值相同 取beginId+endId小的那一组 同时id1=beginId id2=endId id1对应的N放入arrayN1 id2对应的N放入arrayN2
//每次加入都要判断2个arrayN中是否已达到最大可送单数,其中一个超过则剩余订单全加入另外一个
//最大可送订单数以10点的订单数和临界值2*electricMobile20minsOrderAmount=4比较之后得出
if(10点订单数<=4) {
	orderLimit = 2;
}else {
	orderLimit = 4;	
}
if(arrayN1.length<orderLimit){
arrayN1= [{id:1, distance=1}];
}
if(arrayN2.length<orderLimit){
arrayN2= [{id:2, distance=2}];
}
//根据biginId=arrayN1[0].id  endId=arrayN2[0].id 删除arrayDistanceBetweenN中对应的元素
arrayDistanceBetweenN = [{beginId:1, endId:3, distance=2},{beginId:1, endId:4, distance=3},
						 {beginId:2, endId:3, distance=4},{beginId:2, endId:4, distance=5}
						 {beginId:3, endId:4, distance=8}];
//最大可送订单数以10点的订单数和临界值2*electricMobile20minsOrderAmount=4比较之后得出
if(10点订单数<=4) {
	orderLimit = 2;
}else {
	orderLimit = 4;	
}  
//循环操作
//在arrayDistanceBetweenN中找任意beginId或endId为id1的distance 将最小值赋给minDistance1 compareId1=成对的那个beginId或endId
if(arrayDistanceBetweenN中biginId或endId为arrayN1[0].id){
	minDistance1 = 2;
	compareId1 = 3;
	}
//相同方法得到id2对应的minDistance2 compareId2
if(arrayDistanceBetweenN中biginId或endId为arrayN2[0].id){
	minDistance2 = 4;
	compareId2 = 3;
	}	
//看2个compareId是否相同
if(compareId1 != compareId2){
	//deleteId1=id1 id1=compareId1同理得到deleteId2 id2
	//通过deleteId1 deleteId2删除arrayDistanceBetweenN中与它们相等的beginId或endId对应的元素
	//将id1和id2对应的N放入arrayN1和arrayN2 还要判断orderLimit
	if(arrayN1.length<orderLimit){加入}
	else{不再给arrayN1增加订单};
	if(arrayN2.length<orderLimit){加入}
	else{不再给arrayN2增加订单};
	}

if(compareId1 = compareId2) {
	if(minDistance1>minDistance2) //deleteId1=id1 id1=compareId1 对arrayDistanceBetweenN进行删除操作 将id1对应的N放入arrayN1
	else if(minDistance1<minDistanec2){
		//同理
		if(arrayN1.length<orderLimit){
		arrayN1= [{id:1, distance=1},{id:3,distance=3}];
		}
		if(arrayN2.length<orderLimit){
		arrayN2= [{id:2, distance=2}];
		}
		} 
	else if(minDistance1=minDistanec2) //选择放入arrayN1和arrayN2两者中元素个数少的一组
	//else if(arrayN1与arrayN2中的元素个数相等) 一般取后一组
}
//循环如上操作 直到arrayDistanceBetweenN为空 得到arrayN1和arrayN2 它们的格式如同一个送货员算法中的arrayN
        arrayN1= [{id:1, distance=1},{id:3,distance=3}];
		arrayN2= [{id:2, distance=2},{id:4, distance=4}];
//放入DeliveryOrder1和DeliveryOrder2中
deliveryOrder1 = [timePeriod:{10:[{orderId:0, id:1},{orderId:0, id:3}], 11:[], 12...}];
deliveryOrder2 = [timePeriod:{10:[{orderId:0, id:2},{orderId:0, id:4}], 11:[], 12...}];
//用一个送货员的算法B分别对arrayN1和arrayN2进行计算 得到两条路线deliveryOrder1和deliveryOrder2 也可判断新加的订单是否能在下1小时中发货


//3个送货员   先用算法A确认时间段，再用算法C分块，再用算法B计算精确顺序  
//取出arrayN中distance最大的  计算其他订单与这2个订单的距离  设一个参数作为匹配值，如果与其中一个订单距离大于最大送货距离的一半，则匹配值+1，与二个订单的距离
//都大于最大送货距离的一半，则+2
//取出匹配值为2的所以3个订单  计算3个订单的相距之和，取出最大的将这3个订单分配给3个送货员
if(9:00到10:00时间段的订单数==12 || (9:00之前确定的9:00到10:00的订单数<=6 && 9:00到9:20的10:00订单数==4) || orderClock > 9:20){
	订单放入下一小时并再用算法A计算订单是否能放入下一小时，若不能放入则用算法A计算再下一小时的情况
	}
//现假设进来如下订单
N1 = {id:1, distance=1, orderClock:9:05, weight:15, arriveBeginClock:9:00, arriveEndClock:10:00};
N2 = {id:2, distance=2, orderClock:9:10, weight:26, arriveBeginClock:9:00, arriveEndClock:10:00};
N3 = {id:3, distance=3, orderClock:9:15, weight:40, arriveBeginClock:9:00, arriveEndClock:10:00};
N4 = {id:4, distance=4, orderClock:9:16, weight:20, arriveBeginClock:9:00, arriveEndClock:10:00};
N5 = {id:5, distance=3, orderClock:9:17, weight:30, arriveBeginClock:9:00, arriveEndClock:10:00};
N6 = {id:6, distance=5, orderClock:9:18, weight:40, arriveBeginClock:9:00, arriveEndClock:10:00};
N7 = {id:7, distance=4, orderClock:9:19, weight:45, arriveBeginClock:9:00, arriveEndClock:10:00};
//根据算法A的条件判断deliveryOrder的内的订单
deliveryOrder = [timePeriod:{10:[{orderId:0, id:1},{orderId:0, id:2},{orderId:0, id:3},{orderId:0, id:4},{orderId:0, id:5},{orderId:0, id:6}], 11:[{orderId:0,id:7}], 12...}];
//以下为算法A  时间段9:20到10:20
arrayN = [{id:1, distance=1}, {id:2, distance=2},{id:3, distance=3},{id:4, distance=4},{id:5, distance=5},{id:6, distance=6}];
arrayDistanceBetweenN = [{beginId:1, endId:2, distance=10}, {beginId:1, endId:3, distance=2},{beginId:1,endId:4,distance=3},{beginId:1, endId:5, distance=6},{beginId:1, endId:6,distance=8},
						 {beginId:2, endId:3, distance=4},{beginId:2, endId:4, distance=5},{beginId:2, endId:5, distance=7},{beginId:2, endId:6, distance=3}
						 {beginId:3, endId:4, distance=8},{beginId:3, endId:5, distance=8},{beginId:3, endId:6, distance=3},
						 {beginId:4, endId:5, distance=8},{beginId:4, endId:6, distance=1},
						 {beginId:5, endId:6, distance=3}];
//取出arrayN中distance最大的 arrayDistanceBetweenN[1]
//计算其他与arrayDistanceBetweenN[1]的2个订单相关的距离 设一个参数作为匹配值，如果与其中一个订单距离大于最大送货距离的一半则匹配值+1，与二个订单的距离都大于最大送货距离的一半，则+2
//arrayDistanceBetweenN中匹配值为2的有3个  分别为订单4，订单5，订单6
//计算这3个订单如1到4的距离为3，2到4的距离为5，则总和为7，1到5距离为6，2到5距离为7，则总和为13...
//订单4总和为7，订单5总和为13，订单6为11，订单5最大，所以将订单1，2，5交给3个送货员
arrayN1=[{id:1, distance=1}];
arrayN2=[{id:2, distance=2}];
arrayN3=[{id:5, distance=5}];
//按二个送货员的方法类推出每个arrayN的值放入deliveryOrder中
deliveryOrder1=[{...}];
deliveryOrder2=[{...}];
deliveryOrder3=[{...}];
//用一个送货员的算法B分别对arrayN1,arrayN2,N3进行计算 得到三条路线deliveryOrder1，deliveryOrder2和3 也可判断新加的订单是否能在下1小时中发货


//N个送货员算法与3个送货员类似   比如4个就在计算4个订单之间的所有相应距离  取出匹配值为3个   计算4个订单之间相距的最大值后操作